home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Languages / PowerMacOberon 1.2 / Debugger / RTDD.Mod (.txt) < prev    next >
Encoding:
Oberon Text  |  1995-08-07  |  14.5 KB  |  404 lines  |  [TEXT/.Ob4]
  1. Syntax10.Scn.Fnt
  2. StampElems
  3. Alloc
  4. 7 Aug 95
  5. InfoElems
  6. Alloc
  7. Syntax10.Scn.Fnt
  8. StampElems
  9. Alloc
  10. 7 Aug 95
  11. "Title": Run time debugger
  12. "Author": mah
  13. "Abstract": data texts module
  14. "Keywords": 
  15. "Version": 
  16. "From":  31.1.95 11:49:38
  17. "Until": 
  18. "Changes": 
  19. 20.03.95    : statt = jetzt : bei arrays
  20. 28.03.95    FoldElems be records & arrays komprimierter
  21. ParcElems
  22. Alloc
  23. Syntax10i.Scn.Fnt
  24. FoldElems
  25. Syntax10.Scn.Fnt
  26.         indent : INTEGER;
  27.         obj: RTDC.Sym;
  28.         adr: LONGINT;
  29.     END;
  30. Syntax10.Scn.Fnt
  31.         indent: INTEGER;
  32.         writer: Texts.Writer;
  33.         text: Texts.Text;
  34.         baseAdr: LONGINT;
  35.         reg: Sys.ExceptionInfo
  36.     END;
  37. Syntax10b.Scn.Fnt
  38. Syntax10.Scn.Fnt
  39. VAR e: FoldElem;
  40. BEGIN
  41.     NEW (e); e.mode := mode; e.W := FoldElems.elemW; e.H := FoldElems.elemH; e.handle := FoldElemHandler;
  42.     e.obj:=obj; e.adr:=adr; e.indent:=indent; e.visible:=TRUE;
  43.     IF (mode = FoldElems.expLeft) OR (mode = FoldElems.colLeft) THEN NEW (e.hidden); Texts.OpenBuf (e.hidden) END;
  44.     RETURN e
  45. END AllocFoldElem;
  46. Syntax10.Scn.Fnt
  47. VAR i : INTEGER;
  48. BEGIN FOR i := 1 TO in DO Texts.Write (w, 09X) END
  49. END WriteIndent;
  50. Syntax10.Scn.Fnt
  51. Syntax10i.Scn.Fnt
  52.     c: CHAR;
  53.     l: LONGINT;
  54.     i: INTEGER;
  55.     r: REAL;
  56.     lr: LONGREAL;
  57.     s: SET;
  58.     si: SHORTINT;
  59.     name: ARRAY 64 OF CHAR;
  60.     first: BOOLEAN;
  61. BEGIN
  62.     CASE o.typ.form OF
  63.           Byte:
  64.                 IF reg THEN SYS.GET (adr, l); c := CHR(SHORT(SHORT(l))) ELSE SYS.GET (adr, c) END;
  65.                 Texts.WriteInt (w, ORD(c), 0)
  66.         | Bool:
  67.                 IF reg THEN
  68.                     IF adr # 0 THEN c := CHR (1) ELSE c := CHR (0) END
  69.                 ELSE
  70.                     SYS.GET (adr, c)
  71.                 END;
  72.                 IF ORD (c) # 0 THEN Texts.WriteString(w, "TRUE") ELSE Texts.WriteString(w, "FALSE") END
  73.         | Char:
  74.                 IF reg THEN SYS.GET (adr, l); c := CHR (SHORT (SHORT (l))) ELSE SYS.GET (adr, c) END;
  75.                 IF (c < ' ') OR (c > '~') THEN
  76.                     Texts.WriteString (w, "CHR (");
  77.                     Texts.WriteInt (w, ORD(c), 0);
  78.                     Texts.Write (w, ')')
  79.                 ELSE 
  80.                     Texts.Write (w, 27X); Texts.Write (w, c); Texts.Write (w, 27X)
  81.                 END
  82.         | SInt:
  83.                 IF reg THEN SYS.GET (adr, l); si := SHORT (SHORT (l)) ELSE SYS.GET (adr, si) END;
  84.                 Texts.WriteInt (w, si, 0)
  85.         | Int: 
  86.                 IF reg THEN SYS.GET (adr, l) ELSE SYS.GET (adr, i); l := i END;
  87.                 Texts.WriteInt (w, l, 0)
  88.         | LInt:
  89.                 SYS.GET (adr, l);
  90.                 Texts.WriteInt (w, l, 0) 
  91.         | Real: 
  92.                 IF reg THEN SYS.GET (adr, lr); r := SHORT (lr) ELSE SYS.GET (adr, r) END;
  93.                 Texts.WriteLongReal (w, r, 15)
  94.         | LReal: 
  95.                 SYS.GET (adr, lr);
  96.                 Texts.WriteLongReal (w, lr, 20)
  97.         | Set: 
  98.                 SYS.GET (adr, s);
  99.                 first := TRUE;
  100.                 Texts.Write (w, '{');
  101.                 FOR i := 0 TO 31 DO
  102.                     IF i IN s THEN
  103.                         IF ~first THEN Texts.WriteString (w, ", ") END;
  104.                         Texts.WriteInt (w, i, 0);
  105.                         first := FALSE
  106.                     END
  107.                 END;
  108.                 Texts.Write (w, '}')
  109.         |Pointer: Texts.WriteString (w, "NIL")            (* only nil pointers handled here *) 
  110.         |ProcTyp:
  111.                 SYS.GET (adr, l);
  112.                 RTDT.FindProc (l, name);
  113.                 IF name = "" THEN
  114.                     Texts.WriteHex (w, l); Texts.Write (w, 'H')
  115.                 ELSE
  116.                     Texts.WriteString (w, name)
  117.                 END
  118.         |Comp: (* array of char *)
  119.                     IF o.typ.comp = DynArr THEN SYS.GET (adr, o.typ.n); INC (adr, 4) END;
  120.                     SYS.GET (adr, c);
  121.                     Texts.Write (w, '"');
  122.                     i := 1;
  123.                     WHILE c#CHR(0) DO Texts.Write (w, c); SYS.GET (adr+i, c); INC (i) END;
  124.                     Texts.Write (w, '"')
  125.         ELSE
  126.             Texts.WriteString (w, "Unknown type")
  127. END ShowValue;
  128. Syntax10.Scn.Fnt
  129. BEGIN adr := baseAdr + o.adr
  130. END CalcGlobalAdr;
  131. Syntax10.Scn.Fnt
  132. Syntax10i.Scn.Fnt
  133. VAR l : LONGINT;
  134. BEGIN
  135.     IF (o.typ.form = Comp) & (o.typ.comp = Array) &
  136.         (o.typ.BaseTyp.strobj # NIL) &
  137.         (o.typ.BaseTyp.strobj.name = "CHAR") THEN            (* array of char as string *)
  138.             RETURN FALSE
  139.     END;
  140.     IF o.typ.form = Comp THEN RETURN TRUE END;        (* arrays & records *)
  141.     IF o.typ.form # Pointer THEN RETURN FALSE END;
  142.     SYS.GET (adr, l);
  143.     IF l = 0 THEN RETURN FALSE END;                        (* pointer to NIL *)
  144.     RETURN TRUE
  145. END IsComplex;
  146. Syntax10.Scn.Fnt
  147. VAR r: Texts.Reader; f: FoldElem;
  148. l1, l2: LONGINT;
  149. BEGIN
  150.     IF t # NIL THEN
  151.         Texts.OpenReader (r, t, 0); Texts.ReadElem (r);
  152.         WHILE ~r.eot DO
  153.             IF r.elem IS FoldElem THEN
  154.                 f := r.elem(FoldElem);
  155. IF f.mode = FoldElems.expLeft THEN
  156.     l1 := adr; l2 := f.adr;
  157.     IF type.form = 13 THEN
  158.         SYS.GET (adr, l1); SYS.GET (f.adr, l2);
  159.     END;
  160. (*                IF (f.adr = adr) & (f.obj.typ = type) THEN RETURN f.mode = FoldElems.expLeft END  *)
  161.                 IF (l1 = l2) & (f.obj.typ = type) THEN RETURN f.mode = FoldElems.expLeft END 
  162.         END;
  163.             Texts.ReadElem (r)
  164.         END
  165.     END;
  166.     RETURN FALSE    
  167. END Opened;
  168. Syntax10.Scn.Fnt
  169. Syntax10i.Scn.Fnt
  170. VAR o: RTDC.Sym; t: Types.Type;
  171. BEGIN
  172.     IF (obj.mode = 2) & (obj.adr # 0) THEN  (* record as var par or record by pointer *)
  173.         t := SYS.VAL (Types.Type, obj.adr)
  174.     END;
  175. IF SYS.VAL (LONGINT, t) = -1 THEN RETURN END;
  176.     IF (t # NIL) & (t.name[0] # CHR(0)) THEN o := RTDC.FindType (t, t.module) END;
  177. (*    IF o # NIL THEN obj.typ := o.typ END *)
  178. END GetType;
  179. Syntax10.Scn.Fnt
  180.     dim, i, j: LONGINT;
  181.     sn, s, sb: RTDC.Type;
  182.     n: ARRAY 20 OF LONGINT; 
  183. BEGIN
  184.     dim := o.typ.n; 
  185.     s := o.typ;
  186.     FOR i := 0 TO dim DO
  187.         NEW (sn); sn^ := s^; sn.comp := 2;
  188.         IF i = 0 THEN o.typ := sn ELSE sb.BaseTyp := sn END;
  189.         sb := sn;
  190.         SYS.GET (adr + 4 * i + 12, sn.n);
  191.         n[i] := sn.n;
  192.         s := s.BaseTyp
  193.     END;
  194.     sn := o.typ; i := dim;
  195.     REPEAT
  196.         s := o.typ;
  197.         j := 0; WHILE j # i DO INC (j); s := s.BaseTyp END;
  198.         s.size := n[i] * s.BaseTyp.size;
  199.         DEC (i)
  200.     UNTIL i = -1;
  201.     adr := adr + 12 + 4 * (dim + 1);
  202.     INC (adr, (-adr) MOD 8)
  203. END ConvertDynamic;
  204. Syntax10.Scn.Fnt
  205. Syntax10i.Scn.Fnt
  206.     obj: RTDC.Sym;
  207.     i, a: LONGINT;
  208. BEGIN
  209.     IF o.typ.form = Pointer THEN
  210.         SYS.GET (adr, adr);
  211.         SYS.GET (adr - 4, a);
  212.         SYS.GET (a - 4, a);                (* fetch super tag *)
  213.         NEW (obj); obj^ := o^; o := obj;
  214.         o.adr := a - 2;                    (* remove mark bit *)
  215.         o.mode := 2;                        (* mark for possible different runtimetype *)
  216.         o.typ:=o.typ.BaseTyp
  217.     END;
  218.     IF o.typ.comp = DynArr THEN
  219.         ConvertDynamic (o, adr);    
  220.     END;
  221.     NEW (obj);
  222.     obj.typ:=o.typ.BaseTyp;
  223.     IF o.typ.comp = Array THEN
  224.         IF IsComplex (o, adr) THEN
  225.             FOR i := 0 TO o.typ.n-1 DO
  226.                 Texts.WriteLn (w);
  227.                 WriteIndent (w, indent);
  228.                 IF IsComplex (obj, adr + i * obj.typ.size) THEN
  229.                     IF obj.typ.comp = Record THEN Texts.WriteString (w, "RECORD ")
  230.                     ELSIF obj.typ.comp = Array THEN Texts.WriteString (w, "ARRAY ")
  231.                     ELSE Texts.WriteString (w, "POINTER ")
  232.                     END;
  233.                     Texts.WriteInt (w, i, 0); Texts.Write (w, ' ');
  234.                     IF Opened (t, adr+i*obj.typ.size, obj.typ) THEN
  235.                         Texts.WriteElem (w, AllocFoldElem (obj, adr+i*obj.typ.size, indent + 1, FoldElems.expLeft));
  236.                         ShowExpansion (w, obj, adr+i*obj.typ.size, indent + 1, t);
  237.                         Texts.WriteElem (w, AllocFoldElem (obj, adr+i*obj.typ.size, indent + 1, FoldElems.expRight))
  238.                     ELSE
  239.                         Texts.WriteElem (w, AllocFoldElem (obj, adr+i*obj.typ.size, indent + 1, FoldElems.colLeft));
  240.                         Texts.WriteElem (w, AllocFoldElem (obj, adr+i*obj.typ.size, indent + 1, FoldElems.colRight))
  241.                     END
  242.                 ELSE
  243.                     Texts.WriteInt (w, i, 0); Texts.WriteString (w, ": ");
  244.                     ShowValue (w, obj, adr + i * o.typ.BaseTyp.size, FALSE)
  245.                 END
  246.             END
  247.         ELSE                            (* ARRAY OF CHAR *)
  248.             Texts.Write (w, ' ');
  249.             ShowValue (w, o, adr, FALSE)
  250.         END;
  251.         Texts.Write (w, ' ')
  252.     ELSE            (* record *)
  253.         IF o.mode = 2 THEN GetType (o, adr) END;         (* determine runtime type *)
  254.         IF o.typ.BaseTyp#NIL THEN
  255.             obj.typ := o.typ.BaseTyp;
  256.             Texts.Write (w, ' ');
  257.             IF Opened (t, adr, obj.typ) THEN
  258.                 Texts.WriteElem (w, AllocFoldElem (obj, adr, indent, FoldElems.expLeft));
  259.                 ShowExpansion (w, obj, adr, indent, t);
  260.                 Texts.WriteElem (w, AllocFoldElem (obj, adr, indent, FoldElems.expRight))
  261.             ELSE
  262.                 Texts.WriteElem (w, AllocFoldElem (obj, adr, indent, FoldElems.colLeft));
  263.                 Texts.WriteElem (w, AllocFoldElem (obj, adr, indent, FoldElems.colRight))
  264.             END
  265.         END;
  266.         Texts.WriteLn (w);
  267.         GetScope (w, t, o.typ.link, adr, indent);
  268.         Texts.Write (w, ' ')
  269. END ShowExpansion;
  270. Syntax10.Scn.Fnt
  271. VAR w: Texts.Writer; new: FoldElem;
  272. BEGIN
  273.     WITH e: FoldElem DO
  274.         IF (m IS FoldElems.PrepSwitchMsg) & (e.mode = FoldElems.colLeft) THEN
  275.             Texts.OpenWriter (w);
  276.             ShowExpansion (w, e.obj, e.adr, e.indent, Texts.ElemBase (e));
  277.             e.hidden := w.buf
  278.         ELSIF m IS Texts.CopyMsg THEN
  279.             NEW (new); Texts.CopyElem (e, new);
  280.             new.mode := e.mode; new.visible := e.visible;
  281.             IF e.mode IN {FoldElems.colLeft, FoldElems.expLeft, FoldElems.tempLeft, FoldElems.findLeft} THEN
  282.                 NEW(new.hidden); Texts.OpenBuf(new.hidden); Texts.Copy(e.hidden, new.hidden)
  283.             END;
  284.             m(Texts.CopyMsg).e := new
  285.         ELSE
  286.             FoldElems.FoldHandler (e, m)
  287.         END
  288. END FoldElemHandler;
  289. Syntax10.Scn.Fnt
  290. Syntax10i.Scn.Fnt
  291. VAR reg: BOOLEAN; adr: LONGINT; e: FoldElem; 
  292. BEGIN
  293.     IF (obj.mode # 1) & (obj.mode # 2) & (obj.mode # 4) THEN RETURN END; (* VAR, VARPAR, FIELD *)
  294.     IF curView.reg = NIL THEN 
  295.         CalcGlobalAdr (curView.baseAdr, obj, adr); reg := FALSE
  296.     ELSE
  297.         CalcLocalAdr (curView.reg, obj, adr, reg)
  298.     END;
  299.     IF inhibit THEN inhibit := FALSE ELSE Texts.WriteLn (curView.writer) END;
  300.     WriteIndent (curView.writer, curView.indent); Texts.WriteString (curView.writer, obj.name);
  301.     IF obj.typ.form = 13 THEN Texts.Write (curView.writer, '^') END;
  302.     Texts.Write (curView.writer, ' ');
  303.     IF IsComplex (obj, adr) THEN
  304.         IF Opened (curView.text, adr, obj.typ) THEN
  305.             e := AllocFoldElem (obj, adr, curView.indent + 1, FoldElems.expLeft); 
  306.             Texts.WriteElem (curView.writer, e);
  307.             ShowExpansion (curView.writer, obj, adr, curView.indent + 1, curView.text);
  308.             e := AllocFoldElem (obj, adr, curView.indent + 1, FoldElems.expRight);
  309.             Texts.WriteElem (curView.writer, e)
  310.         ELSE
  311.             e := AllocFoldElem (obj, adr, curView.indent + 1, FoldElems.colLeft); 
  312.             Texts.WriteElem (curView.writer, e);
  313.             e := AllocFoldElem (obj, adr, curView.indent + 1, FoldElems.colRight);
  314.             Texts.WriteElem (curView.writer, e)
  315.         END
  316.     ELSE
  317.         Texts.WriteString (curView.writer, "= ");
  318.         ShowValue (curView.writer, obj, adr, reg)
  319. END CollectProc;
  320. Syntax10.Scn.Fnt
  321. VAR v, old: View;
  322. BEGIN
  323.     NEW (v); v.indent := indent; v.baseAdr := baseAdr; v.text := t; v.writer := w;
  324.     old := curView; curView := v;
  325.     inhibit := TRUE; RTDC.ScanScope (syms, CollectProc);
  326.     w := v.writer; curView := old
  327. END GetScope;
  328. Syntax10.Scn.Fnt
  329. VAR v, old: View;
  330. BEGIN
  331.     NEW (v); v.indent := indent; v.reg := reg; v.text := t; v.writer := w;
  332.     old := curView; curView := v;
  333.     inhibit := TRUE; RTDC.ScanScope (syms, CollectProc);
  334.     w := v.writer; curView := old
  335. END GetLocalScope;
  336. MODULE RTDD; (* Run time debugger: Data texts; mah 31.1.95 (
  337. IMPORT RTDT, RTDC, Texts, TextFrames, SYS := SYSTEM, FoldElems, Modules, Types, Sys;
  338. CONST
  339.     (* structure forms *)
  340.     Undef = 0; Byte = 1; Bool = 2; Char = 3; SInt = 4; Int = 5; LInt = 6;
  341.     Real = 7; LReal = 8; Set = 9; String = 10; NilTyp = 11; NoTyp = 12;
  342.     Pointer = 13; ProcTyp = 14; Comp = 15;
  343.     (* composite structure forms *)
  344.     Basic = 1; Array = 2; DynArr = 3; Record = 4;
  345.     FoldElem = POINTER TO FoldElemDesc;
  346.     FoldElemDesc = RECORD (FoldElems.ElemDesc)
  347.     View = POINTER TO ViewDesc;
  348.     ViewDesc = RECORD
  349.     curView: View;
  350.     inhibit: BOOLEAN;
  351. PROCEDURE ^FoldElemHandler (e: Texts.Elem; VAR m: Texts.ElemMsg);
  352. PROCEDURE ^GetScope* (VAR w: Texts.Writer; t: Texts.Text; syms: RTDC.Sym; baseAdr: LONGINT; indent: INTEGER);
  353. PROCEDURE AllocFoldElem (obj: RTDC.Sym; adr: LONGINT; indent: INTEGER; mode: SHORTINT) : FoldElem;
  354. PROCEDURE WriteIndent (VAR w: Texts.Writer; in : INTEGER);
  355.  Write 'in' tabs 
  356. PROCEDURE ShowValue (VAR w: Texts.Writer; o : RTDC.Sym; adr : LONGINT; reg : BOOLEAN);
  357. PROCEDURE CalcGlobalAdr (baseAdr: LONGINT; o: RTDC.Sym; VAR adr: LONGINT);
  358. PROCEDURE CalcLocalAdr (regs: Sys.ExceptionInfo; o: RTDC.Sym; VAR adr: LONGINT; VAR reg: BOOLEAN);
  359. VAR nxt, l: LONGINT;
  360. BEGIN
  361.     IF o.linkadr < 0 THEN
  362.         reg := TRUE;
  363.           adr := -1 - o.linkadr; 
  364.         adr := adr MOD 32;
  365.         IF (o.typ.comp = Record) & (o.mode = 2) THEN
  366.             SYS.GET (regs.reg.R[2 * adr + 3] - 4, l); o.adr := l - 2
  367.         ELSIF (o.typ.comp = DynArr) & (o.mode # 2) THEN
  368.             SYS.GET (regs.reg.R[2 * adr + 3] - 4, l); o.adr := l - 2
  369.         ELSE
  370.             o.adr := 0
  371.         END;
  372.         IF adr < 31 THEN nxt := regs.reg.R[2 * adr + 3] END;
  373.         IF o.typ.form = ProcTyp THEN adr := SYS.ADR (regs.reg.R[2 * adr + 1])
  374.         ELSIF o.typ.form = Bool THEN
  375.             IF adr IN SYS.VAL(SET, regs.spec.CR) THEN adr := 1 ELSE adr := 0 END
  376.         ELSE
  377.             IF (o.typ.form = LReal) OR (o.typ.form = Real) THEN
  378.                 adr := SYS.ADR (regs.fp.R[2 * adr])
  379.             ELSE 
  380.                 adr := SYS.ADR (regs.reg.R[2 * adr + 1])
  381.             END
  382.         END
  383.     ELSE
  384.         reg := FALSE;
  385.         adr := o.linkadr + regs.reg.R[2 * 31 + 1]
  386.     END;
  387.     IF (o.mode = 2) OR ((o.typ.form = Comp) & (o.typ.comp = DynArr)) THEN SYS.GET (adr, adr); reg := FALSE END;
  388.     IF (o.typ.form = Comp) & (o.typ.comp = DynArr) THEN
  389.         o.typ.n := nxt;
  390.         o.typ.comp := Array
  391. END CalcLocalAdr;
  392. PROCEDURE IsComplex (o : RTDC.Sym; adr : LONGINT) : BOOLEAN;
  393. PROCEDURE Opened (t: Texts.Text; adr: LONGINT; type: RTDC.Type) : BOOLEAN;
  394. PROCEDURE GetType (VAR obj: RTDC.Sym; adr: LONGINT);
  395.  converts obj.typ to actual runtime type 
  396. PROCEDURE ConvertDynamic (VAR o: RTDC.Sym; VAR adr: LONGINT);
  397.  converts DynArray to Array 
  398. PROCEDURE ShowExpansion (VAR w: Texts.Writer; o: RTDC.Sym; adr: LONGINT; indent: INTEGER; t: Texts.Text);
  399. PROCEDURE FoldElemHandler (e: Texts.Elem; VAR m: Texts.ElemMsg);
  400. PROCEDURE CollectProc (obj: RTDC.Sym);
  401. PROCEDURE GetScope* (VAR w: Texts.Writer; t: Texts.Text; syms: RTDC.Sym; baseAdr: LONGINT; indent: INTEGER);
  402. PROCEDURE GetLocalScope* (VAR w: Texts.Writer; t: Texts.Text; syms: RTDC.Sym; reg: Sys.ExceptionInfo; indent: INTEGER);
  403. END RTDD.
  404.